home *** CD-ROM | disk | FTP | other *** search
/ Aminet 25 / Aminet 25 (1998)(GTI - Schatztruhe)[!][Jun 1998].iso / Aminet / game / shoot / ADoom_src_1_2.lha / ADoom_src / w_wad.c < prev    next >
C/C++ Source or Header  |  1998-02-18  |  11KB  |  604 lines
  1. // Emacs style mode select   -*- C++ -*- 
  2. //-----------------------------------------------------------------------------
  3. //
  4. // $Id:$
  5. //
  6. // Copyright (C) 1993-1996 by id Software, Inc.
  7. //
  8. // This source is available for distribution and/or modification
  9. // only under the terms of the DOOM Source Code License as
  10. // published by id Software. All rights reserved.
  11. //
  12. // The source is distributed in the hope that it will be useful,
  13. // but WITHOUT ANY WARRANTY; without even the implied warranty of
  14. // FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
  15. // for more details.
  16. //
  17. // $Log:$
  18. //
  19. // DESCRIPTION:
  20. //    Handles WAD file header, directory, lump I/O.
  21. //
  22. //-----------------------------------------------------------------------------
  23.  
  24.  
  25. static const char
  26. rcsid[] = "$Id: w_wad.c,v 1.5 1997/02/03 16:47:57 b1 Exp $";
  27.  
  28.  
  29. #ifdef NORMALUNIX
  30. #ifndef __SASC
  31. #include <ctype.h>
  32. #include <sys/types.h>
  33. #include <string.h>
  34. #include <unistd.h>
  35. #include <malloc.h>
  36. #include <fcntl.h>
  37. #include <sys/stat.h>
  38. #include <alloca.h>
  39. #define O_BINARY        0
  40. #else
  41. #include <stdio.h>
  42. #include <stdlib.h>
  43. #include <string.h>
  44. #include <ctype.h>
  45. #include <stat.h>
  46. #endif
  47. #endif
  48.  
  49. #include "doomdef.h"
  50. #include "doomtype.h"
  51. #include "m_swap.h"
  52. #include "i_system.h"
  53. #include "z_zone.h"
  54.  
  55. #ifdef __GNUG__
  56. #pragma implementation "w_wad.h"
  57. #endif
  58. #include "w_wad.h"
  59.  
  60.  
  61.  
  62.  
  63.  
  64.  
  65. //
  66. // GLOBALS
  67. //
  68.  
  69. // Location of each lump on disk.
  70. lumpinfo_t*        lumpinfo;        
  71. int            numlumps;
  72.  
  73. void**            lumpcache;
  74.  
  75.  
  76. #ifndef __SASC
  77. #define strcmpi    strcasecmp
  78.  
  79. void strupr (char* s)
  80. {
  81.     while (*s) { *s = toupper(*s); s++; }
  82. }
  83. #endif
  84.  
  85. int filelength (int handle) 
  86. { 
  87.     struct stat    *fileinfo;
  88.     int size;
  89.     
  90.     if ((fileinfo = malloc (sizeof(struct stat))) == NULL ||
  91.         fstat (handle,fileinfo) == -1)
  92.     I_Error ("Error fstating");
  93.     size = fileinfo->st_size;
  94.     free (fileinfo);
  95.  
  96.     return size;
  97. }
  98.  
  99.  
  100. void
  101. ExtractFileBase
  102. ( char*        path,
  103.   char*        dest )
  104. {
  105.     char*    src;
  106.     int        length;
  107.  
  108.     src = path + strlen(path) - 1;
  109.     
  110.     // back up until a \ or the start
  111.     while (src != path
  112.        && *(src-1) != '\\'
  113.        && *(src-1) != '/')
  114.     {
  115.     src--;
  116.     }
  117.     
  118.     // copy up to eight characters
  119.     memset (dest,0,8);
  120.     length = 0;
  121.     
  122.     while (*src && *src != '.')
  123.     {
  124.     if (++length == 9)
  125.         I_Error ("Filename base of %s >8 chars",path);
  126.  
  127.     *dest++ = toupper((int)*src++);
  128.     }
  129. }
  130.  
  131.  
  132.  
  133.  
  134.  
  135. //
  136. // LUMP BASED ROUTINES.
  137. //
  138.  
  139. //
  140. // W_AddFile
  141. // All files are optional, but at least one file must be
  142. //  found (PWAD, if all required lumps are present).
  143. // Files with a .wad extension are wadlink files
  144. //  with multiple lumps.
  145. // Other files are single lumps with the base filename
  146. //  for the lump name.
  147. //
  148. // If filename starts with a tilde, the file is handled
  149. //  specially to allow map reloads.
  150. // But: the reload feature is a fragile hack...
  151.  
  152. int            reloadlump;
  153. char*            reloadname;
  154.  
  155.  
  156. void W_AddFile (char *filename)
  157. {
  158.     wadinfo_t        header;
  159.     lumpinfo_t*        lump_p;
  160.     unsigned        i;
  161.     FILE        *handle;
  162.     int            length;
  163.     int            startlump;
  164.     filelump_t*        fileinfo = NULL;
  165.     filelump_t        singleinfo, *fi;
  166.     FILE        *storehandle;
  167.     int                 fileinfo_allocated = 0;
  168.     
  169.     // open the file and add to directory
  170.  
  171.     // handle reload indicator.
  172.     if (filename[0] == '~')
  173.     {
  174.     filename++;
  175.     reloadname = filename;
  176.     reloadlump = numlumps;
  177.     }
  178.         
  179.     if ( (handle = fopen (filename,"r")) == NULL)
  180.     {
  181.     printf (" couldn't open %s\n",filename);
  182.     return;
  183.     }
  184.  
  185.     printf (" adding %s\n",filename);
  186.     startlump = numlumps;
  187.     
  188.     if (strcmpi (filename+strlen(filename)-3 , "wad" ) )
  189.     {
  190.     // single lump file
  191.     fileinfo = &singleinfo;
  192.     singleinfo.filepos = 0;
  193.     singleinfo.size = SWAPLONG(filelength(fileno(handle)));
  194.     ExtractFileBase (filename, singleinfo.name);
  195.     numlumps++;
  196.     }
  197.     else 
  198.     {
  199.     // WAD file
  200.     fread (&header, 1, sizeof(header), handle);
  201.     if (strncmp(header.identification,"IWAD",4))
  202.     {
  203.         // Homebrew levels?
  204.         if (strncmp(header.identification,"PWAD",4))
  205.         {
  206.         I_Error ("Wad file %s doesn't have IWAD "
  207.              "or PWAD id\n", filename);
  208.         }
  209.         
  210.         // ???modifiedgame = true;        
  211.     }
  212.     header.numlumps = SWAPLONG(header.numlumps);
  213.     header.infotableofs = SWAPLONG(header.infotableofs);
  214.     length = header.numlumps*sizeof(filelump_t);
  215.     fileinfo = malloc (length);
  216.         fileinfo_allocated = 1;
  217.     fseek (handle, header.infotableofs, SEEK_SET);
  218.     fread (fileinfo, 1, length, handle);
  219.     numlumps += header.numlumps;
  220.     }
  221.  
  222.     
  223.     // Fill in lumpinfo
  224.     lumpinfo = realloc (lumpinfo, numlumps*sizeof(lumpinfo_t));
  225.  
  226.     if (!lumpinfo)
  227.     I_Error ("Couldn't realloc lumpinfo");
  228.  
  229.     lump_p = &lumpinfo[startlump];
  230.     
  231.     storehandle = reloadname ? NULL : handle;
  232.  
  233.     fi = fileinfo;
  234.     for (i=startlump ; i<numlumps ; i++,lump_p++, fi++)
  235.     {
  236.     lump_p->handle = storehandle;
  237.     lump_p->position = SWAPLONG(fi->filepos);
  238.     lump_p->size = SWAPLONG(fi->size);
  239.     strncpy (lump_p->name, fi->name, 8);
  240.     }
  241.     
  242.     if (reloadname)
  243.     fclose (handle);
  244.     if (fileinfo_allocated)
  245.         free (fileinfo);
  246. }
  247.  
  248.  
  249.  
  250.  
  251. //
  252. // W_Reload
  253. // Flushes any of the reloadable lumps in memory
  254. //  and reloads the directory.
  255. //
  256. void W_Reload (void)
  257. {
  258.     wadinfo_t        header;
  259.     int            lumpcount;
  260.     lumpinfo_t*        lump_p;
  261.     unsigned        i;
  262.     FILE        *handle;
  263.     int            length;
  264.     filelump_t*        fileinfo = NULL;
  265.     filelump_t*         fi;
  266.  
  267.     if (!reloadname)
  268.     return;
  269.  
  270.     if ( (handle = fopen (reloadname,"r")) == NULL)
  271.     I_Error ("W_Reload: couldn't open %s",reloadname);
  272.  
  273.     fread (&header, 1, sizeof(header), handle);
  274.     lumpcount = SWAPLONG(header.numlumps);
  275.     header.infotableofs = SWAPLONG(header.infotableofs);
  276.     length = lumpcount*sizeof(filelump_t);
  277.     fileinfo = malloc (length);
  278.     fseek (handle, header.infotableofs, SEEK_SET);
  279.     fread (fileinfo, 1, length, handle);
  280.  
  281.     // Fill in lumpinfo
  282.     lump_p = &lumpinfo[reloadlump];
  283.     
  284.     fi = fileinfo;
  285.     for (i=reloadlump ;
  286.      i<reloadlump+lumpcount ;
  287.      i++,lump_p++, fi++)
  288.     {
  289.     if (lumpcache[i])
  290.         Z_Free (lumpcache[i]);
  291.  
  292.     lump_p->position = SWAPLONG(fi->filepos);
  293.     lump_p->size = SWAPLONG(fi->size);
  294.     }
  295.     
  296.     fclose (handle);
  297.     if (fileinfo != NULL)
  298.        free (fileinfo);
  299. }
  300.  
  301.  
  302.  
  303. //
  304. // W_InitMultipleFiles
  305. // Pass a null terminated list of files to use.
  306. // All files are optional, but at least one file
  307. //  must be found.
  308. // Files with a .wad extension are idlink files
  309. //  with multiple lumps.
  310. // Other files are single lumps with the base filename
  311. //  for the lump name.
  312. // Lump names can appear multiple times.
  313. // The name searcher looks backwards, so a later file
  314. //  does override all earlier ones.
  315. //
  316. void W_InitMultipleFiles (char** filenames)
  317. {    
  318.     int        size;
  319.     
  320.     // open all the files, load headers, and count lumps
  321.     numlumps = 0;
  322.  
  323.     // will be realloced as lumps are added
  324.     lumpinfo = malloc(1);    
  325.  
  326.     for ( ; *filenames ; filenames++)
  327.     W_AddFile (*filenames);
  328.  
  329.     if (!numlumps)
  330.     I_Error ("W_InitFiles: no files found");
  331.     
  332.     // set up caching
  333.     size = numlumps * sizeof(*lumpcache);
  334.     lumpcache = malloc (size);
  335.     
  336.     if (!lumpcache)
  337.     I_Error ("Couldn't allocate lumpcache");
  338.  
  339.     memset (lumpcache,0, size);
  340. }
  341.  
  342.  
  343.  
  344.  
  345. //
  346. // W_InitFile
  347. // Just initialize from a single file.
  348. //
  349. void W_InitFile (char* filename)
  350. {
  351.     char*    names[2];
  352.  
  353.     names[0] = filename;
  354.     names[1] = NULL;
  355.     W_InitMultipleFiles (names);
  356. }
  357.  
  358.  
  359.  
  360. //
  361. // W_NumLumps
  362. //
  363. int W_NumLumps (void)
  364. {
  365.     return numlumps;
  366. }
  367.  
  368.  
  369.  
  370. //
  371. // W_CheckNumForName
  372. // Returns -1 if name not found.
  373. //
  374.  
  375. int W_CheckNumForName (char* name)
  376. {
  377.     union {
  378.     char    s[9];
  379.     int    x[2];
  380.     
  381.     } name8;
  382.     
  383.     int        v1;
  384.     int        v2;
  385.     lumpinfo_t*    lump_p;
  386.  
  387.     // make the name into two integers for easy compares
  388.     strncpy (name8.s,name,8);
  389.  
  390.     // in case the name was a fill 8 chars
  391.     name8.s[8] = 0;
  392.  
  393.     // case insensitive
  394.     strupr (name8.s);        
  395.  
  396.     v1 = name8.x[0];
  397.     v2 = name8.x[1];
  398.  
  399.  
  400.     // scan backwards so patch lump files take precedence
  401.     lump_p = lumpinfo + numlumps;
  402.  
  403.     while (lump_p-- != lumpinfo)
  404.     {
  405.     if ( *(int *)lump_p->name == v1
  406.          && *(int *)&lump_p->name[4] == v2)
  407.     {
  408.         return lump_p - lumpinfo;
  409.     }
  410.     }
  411.  
  412.     // TFB. Not found.
  413.     return -1;
  414. }
  415.  
  416.  
  417.  
  418.  
  419. //
  420. // W_GetNumForName
  421. // Calls W_CheckNumForName, but bombs out if not found.
  422. //
  423. int W_GetNumForName (char* name)
  424. {
  425.     int    i;
  426.  
  427.     i = W_CheckNumForName (name);
  428.     
  429.     if (i == -1)
  430.       I_Error ("W_GetNumForName: %s not found!", name);
  431.       
  432.     return i;
  433. }
  434.  
  435.  
  436. //
  437. // W_LumpLength
  438. // Returns the buffer size needed to load the given lump.
  439. //
  440. int W_LumpLength (int lump)
  441. {
  442.     if (lump >= numlumps)
  443.     I_Error ("W_LumpLength: %i >= numlumps",lump);
  444.  
  445.     return lumpinfo[lump].size;
  446. }
  447.  
  448.  
  449.  
  450. //
  451. // W_ReadLump
  452. // Loads the lump into the given buffer,
  453. //  which must be >= W_LumpLength().
  454. //
  455. void
  456. W_ReadLump
  457. ( int        lump,
  458.   void*        dest )
  459. {
  460.     int        c;
  461.     lumpinfo_t*    l;
  462.     FILE    *handle;
  463.     
  464.     if (lump >= numlumps)
  465.     I_Error ("W_ReadLump: %i >= numlumps",lump);
  466.  
  467.     l = lumpinfo+lump;
  468.     
  469.     // ??? I_BeginRead ();
  470.     
  471.     if (l->handle == NULL)
  472.     {
  473.     // reloadable file, so use open / read / close
  474.     if ( (handle = fopen (reloadname,"r")) == NULL)
  475.         I_Error ("W_ReadLump: couldn't open %s",reloadname);
  476.     }
  477.     else
  478.     handle = l->handle;
  479.         
  480.     fseek (handle, l->position, SEEK_SET);
  481.     c = fread (dest, 1, l->size, handle);
  482.  
  483.     if (c < l->size)
  484.     I_Error ("W_ReadLump: only read %i of %i on lump %i",
  485.          c,l->size,lump);    
  486.  
  487.     if (l->handle == NULL)
  488.     fclose (handle);
  489.         
  490.     // ??? I_EndRead ();
  491. }
  492.  
  493.  
  494.  
  495.  
  496. #ifndef AMIGA
  497. //
  498. // W_CacheLumpNum
  499. //
  500. void*
  501. W_CacheLumpNum
  502. ( int        lump,
  503.   int        tag )
  504. {
  505.     byte*    ptr;
  506.  
  507.     if ((unsigned)lump >= numlumps)
  508.     I_Error ("W_CacheLumpNum: %i >= numlumps",lump);
  509.         
  510.     if (!lumpcache[lump])
  511.     {
  512.     // read the lump in
  513.     
  514.     //printf ("cache miss on lump %i\n",lump);
  515.     ptr = Z_Malloc (W_LumpLength (lump), tag, &lumpcache[lump]);
  516.     W_ReadLump (lump, lumpcache[lump]);
  517.     }
  518.     else
  519.     {
  520.     //printf ("cache hit on lump %i\n",lump);
  521.     Z_ChangeTag (lumpcache[lump],tag);
  522.     }
  523.     
  524.     return lumpcache[lump];
  525. }
  526. #endif
  527.  
  528.  
  529.  
  530. //
  531. // W_CacheLumpName
  532. //
  533. void*
  534. W_CacheLumpName
  535. ( char*        name,
  536.   int        tag )
  537. {
  538.     return W_CacheLumpNum (W_GetNumForName(name), tag);
  539. }
  540.  
  541.  
  542. //
  543. // W_Profile
  544. //
  545. FAR int        info[2500][10];
  546. int        profilecount;
  547.  
  548. void W_Profile (void)
  549. {
  550.     int        i;
  551.     memblock_t*    block;
  552.     void*    ptr;
  553.     char    ch;
  554.     FILE*    f;
  555.     int        j;
  556.     char    name[9];
  557.     
  558.     
  559.     for (i=0 ; i<numlumps ; i++)
  560.     {    
  561.     ptr = lumpcache[i];
  562.     if (!ptr)
  563.     {
  564.         ch = ' ';
  565.         continue;
  566.     }
  567.     else
  568.     {
  569.         block = (memblock_t *) ( (byte *)ptr - sizeof(memblock_t));
  570.         if (block->tag < PU_PURGELEVEL)
  571.         ch = 'S';
  572.         else
  573.         ch = 'P';
  574.     }
  575.     info[i][profilecount] = ch;
  576.     }
  577.     profilecount++;
  578.     
  579.     f = fopen ("waddump.txt","w");
  580.     name[8] = 0;
  581.  
  582.     for (i=0 ; i<numlumps ; i++)
  583.     {
  584.     memcpy (name,lumpinfo[i].name,8);
  585.  
  586.     for (j=0 ; j<8 ; j++)
  587.         if (!name[j])
  588.         break;
  589.  
  590.     for ( ; j<8 ; j++)
  591.         name[j] = ' ';
  592.  
  593.     fprintf (f,"%s ",name);
  594.  
  595.     for (j=0 ; j<profilecount ; j++)
  596.         fprintf (f,"    %c",info[i][j]);
  597.  
  598.     fprintf (f,"\n");
  599.     }
  600.     fclose (f);
  601. }
  602.  
  603.  
  604.